package haut.system.member.person;

import haut.system.member.events.SportingEvents;
import haut.util.exception.DataException;

import java.util.Scanner;
import java.util.Vector;

/**
 * 裁判类。
 * @author LiangDa Chu
 * @author MingJie Li
 */
public class Judge extends TeaAndStu{

    /**
     * 内部类<code>Events</code>为裁判的评定项目。
     */
    public class Event {

        /**
         * 评定的项目
         */
        SportingEvents event;

        /**
         * <code>Event</code>的内部类<code>ScoreAssessment</code>
         * 是裁判员对评估项目下的所有运动员成绩的判定类。
         */
        class ScoreAssessment {

            /**
             * 项目中的某一位运动员
             */
            Player player;

            /**
             * 项目中的某一运动员的判定成绩
             */
            double score;

            /**
             * 成绩评定类<ScoreAssessment>code</code>的有参构造函数，
             * 接受一个运动员类作为参数，
             * 成绩在未判定之前默认为0.0.
             * @param player 运动员类
             */
            public ScoreAssessment(Player player) {
                this.player = player;
                this.score = 0.0;
            }

            /**
             * 获取运动员类
             * @return {Player} player
             */
            public Player getPlayer() {
                return player;
            }

            /**
             * 为运动员判分
             * @param score 分数
             * @author -LiangDa Chu
             */
            public void setScore(double score) {
                this.score = score;
                //获取该运动员的所有参赛项目
                Vector<Player.Events> myEvents = player.getMyEvents();
                //找到该项目，并为其打分
                for (Player.Events ev : myEvents) {
                    /**
                     * 如果重写了huat.system.member.events.SportingEvents中的equals方法，则这里不用getName()比较也可以
                     */
                    if (ev.events.getName().equals(event.getName())) {
                        ev.score = score;
                    }
                }
            }

            /**
             * 获取运动员的评定分数
             * @return {double} score
             */
            public double getScore() {
                return score;
            }
        }//内部类ScoreAssessment

        /**
         * 本项目下所有运动员的成绩评定
         */
        Vector allPlayer = new Vector<ScoreAssessment>();

        /**
         * 项目评定类<code>Event</code>的有参构造函数
         * @param event 评定的项目
         */
        public Event(SportingEvents event) {
            this.event = event;

            Vector player = event.getPlayer();
            int size = player.size();

            for(int i = 1; i < size; ++i) {
                this.allPlayer.add(new ScoreAssessment((Player) player.get(i)));
            }
        }

        /**
         * 获取评定的项目
         * @return {SportingEvents} event
         */
        public SportingEvents getEvent() {
            return event;
        }

        /**
         * 获取项目运动员的集合
         * @return {Vector} allPlayer
         */
        public Vector getAllPlayer() {
            return allPlayer;
        }
    }//内部类

    /**
     * 该名裁判员的所有评定项目
     */
    Vector<Event> myEvents = new Vector<Event>();

    /**
     * <code>Judge</code>类的有参构造函数。
     *
     * @param stu 师生类
     * @param event 评定项目
     * @throws DataException
     */
    public Judge(TeaAndStu stu, SportingEvents event) throws DataException {
        super(stu.id, stu.name);
        this.myEvents.add(new Event(event));
    }

    /**
     * 为裁判项目下的运动员打分
     * @param id 项目编号
     * @author -LiangDa Chu
     */
    public void markForPlayerOfEvents(String id) throws DataException{
        /**
         * 编号为id的项目
         */
        Judge.Event targetEvent = null;
        //找到该裁判所有项目中项目编号为id的项目
        for (Event ev : myEvents) {
            if (id.equals(ev.event.getId())) {
                targetEvent = ev;
                break;
            }
        }
        if (targetEvent == null) {
            throw new DataException("项目不存在！");
        }

        //获取该项目中的所有运动员
        Vector allPlayer = targetEvent.getAllPlayer();

        //依次为运动员打分
        Scanner sc = new Scanner(System.in);
        double score;
        for (Object obj : allPlayer) {
            Judge.Event.ScoreAssessment p = (Judge.Event.ScoreAssessment) obj;
            System.out.print("请输入运动员（" + p.player.name + "）：");
            score = sc.nextDouble();
            p.setScore(score);

        }

    }

    /**
     * 获得裁判员的评定项目
     * @return
     */
    public Vector<Event> getMyEvents() {
        return myEvents;
    }

    /**
     * 加入新项目
     * @param event
     */
    public void addEvent(SportingEvents event) {
        myEvents.add(new Event(event));
    }

}
